using System;
using System.Collections.Generic;
using ns26;
using ns27;

namespace Triton.Game.Mapping
{
	[Attribute38("SuperSpell")]
	public class SuperSpell : Spell
	{
		public bool m_MakeClones => method_2<bool>("m_MakeClones");

		public SpellTargetInfo m_TargetInfo => method_3<SpellTargetInfo>("m_TargetInfo");

		public SpellStartInfo m_StartInfo => method_3<SpellStartInfo>("m_StartInfo");

		public SpellActionInfo m_ActionInfo => method_3<SpellActionInfo>("m_ActionInfo");

		public SpellMissileInfo m_MissileInfo => method_3<SpellMissileInfo>("m_MissileInfo");

		public SpellImpactInfo m_ImpactInfo => method_3<SpellImpactInfo>("m_ImpactInfo");

		public SpellAreaEffectInfo m_FriendlyAreaEffectInfo => method_3<SpellAreaEffectInfo>("m_FriendlyAreaEffectInfo");

		public SpellAreaEffectInfo m_OpponentAreaEffectInfo => method_3<SpellAreaEffectInfo>("m_OpponentAreaEffectInfo");

		public SpellChainInfo m_ChainInfo => method_3<SpellChainInfo>("m_ChainInfo");

		public Spell m_startSpell => method_3<Spell>("m_startSpell");

		public List<GameObject> m_visualTargets => method_3<Class271<GameObject>>("m_visualTargets")?.method_25();

		public int m_currentTargetIndex => method_2<int>("m_currentTargetIndex");

		public int m_effectsPendingFinish => method_2<int>("m_effectsPendingFinish");

		public bool m_pendingNoneStateChange => method_2<bool>("m_pendingNoneStateChange");

		public bool m_pendingSpellFinish => method_2<bool>("m_pendingSpellFinish");

		public bool m_settingUpAction => method_2<bool>("m_settingUpAction");

		public Spell m_activeAreaEffectSpell => method_3<Spell>("m_activeAreaEffectSpell");

		public SuperSpell(IntPtr address, string className)
			: base(address, className)
		{
		}

		public SuperSpell(IntPtr address)
			: this(address, "SuperSpell")
		{
		}

		public new List<GameObject> GetVisualTargets()
		{
			return method_14<Class271<GameObject>>("GetVisualTargets", Array.Empty<object>())?.method_25();
		}

		public new GameObject GetVisualTarget()
		{
			return method_14<GameObject>("GetVisualTarget", Array.Empty<object>());
		}

		public new void AddVisualTarget(GameObject go)
		{
			method_8("AddVisualTarget", go);
		}

		public new bool RemoveVisualTarget(GameObject go)
		{
			return method_11<bool>("RemoveVisualTarget", new object[1] { go });
		}

		public new void RemoveAllVisualTargets()
		{
			method_8("RemoveAllVisualTargets");
		}

		public new bool IsVisualTarget(GameObject go)
		{
			return method_11<bool>("IsVisualTarget", new object[1] { go });
		}

		public new Card GetVisualTargetCard()
		{
			return method_14<Card>("GetVisualTargetCard", Array.Empty<object>());
		}

		public bool AddPowerTargetsInternal(bool fallbackToStartBlockTarget)
		{
			return method_11<bool>("AddPowerTargetsInternal", new object[1] { fallbackToStartBlockTarget });
		}

		public new bool AddPowerTargets()
		{
			return method_11<bool>("AddPowerTargets", Array.Empty<object>());
		}

		public new void AddTargetFromMetaData(int metaDataIndex, Card targetCard)
		{
			method_8("AddTargetFromMetaData", metaDataIndex, targetCard);
		}

		public new void OnBirth(SpellStateType prevStateType)
		{
			method_8("OnBirth", prevStateType);
		}

		public new void OnAction(SpellStateType prevStateType)
		{
			method_8("OnAction", prevStateType);
		}

		public new void OnCancel(SpellStateType prevStateType)
		{
			method_8("OnCancel", prevStateType);
		}

		public new void OnStateFinished()
		{
			method_8("OnStateFinished");
		}

		public new void OnSpellFinished()
		{
			method_8("OnSpellFinished");
		}

		public void DoAction()
		{
			method_8("DoAction");
		}

		public bool CheckAndWaitForGameEventsThenDoAction()
		{
			return method_11<bool>("CheckAndWaitForGameEventsThenDoAction", Array.Empty<object>());
		}

		public bool DoActionDuringGameEvents()
		{
			return method_11<bool>("DoActionDuringGameEvents", Array.Empty<object>());
		}

		public Entity GetEntityFromZoneChangePowerTask(PowerTask task)
		{
			return method_14<Entity>("GetEntityFromZoneChangePowerTask", new object[1] { task });
		}

		public void DoActionAfterGameEvents()
		{
			method_8("DoActionAfterGameEvents");
		}

		public bool CheckAndWaitForStartDelayThenDoAction()
		{
			return method_11<bool>("CheckAndWaitForStartDelayThenDoAction", Array.Empty<object>());
		}

		public bool CheckAndWaitForStartPrefabThenDoAction()
		{
			return method_11<bool>("CheckAndWaitForStartPrefabThenDoAction", Array.Empty<object>());
		}

		public void OnStartSpellBirthStateFinished(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnStartSpellBirthStateFinished", spell, prevStateType, userData);
		}

		public void DoActionNow()
		{
			method_8("DoActionNow");
		}

		public bool HasStart()
		{
			return method_11<bool>("HasStart", Array.Empty<object>());
		}

		public void SpawnStart()
		{
			method_8("SpawnStart");
		}

		public void DoStartSpellAction()
		{
			method_8("DoStartSpellAction");
		}

		public void OnStartSpellActionFinished(Spell spell, object userData)
		{
			method_8("OnStartSpellActionFinished", spell, userData);
		}

		public bool HasMissile()
		{
			return method_11<bool>("HasMissile", Array.Empty<object>());
		}

		public void SpawnChainMissile()
		{
			method_8("SpawnChainMissile");
		}

		public void SpawnMissileInSequence()
		{
			method_8("SpawnMissileInSequence");
		}

		public void SpawnAllMissiles()
		{
			method_8("SpawnAllMissiles");
		}

		public void SpawnMissile(int targetIndex)
		{
			method_8("SpawnMissile", targetIndex);
		}

		public void OnMissileSpellStateFinished(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnMissileSpellStateFinished", spell, prevStateType, userData);
		}

		public void FireMissileOnPath(Spell missile, int targetIndex, bool reverse)
		{
			method_8("FireMissileOnPath", missile, targetIndex, reverse);
		}

		public List<Vector3> GenerateMissilePath(Spell missile)
		{
			return method_14<Class250<Vector3>>("GenerateMissilePath", new object[1] { missile })?.method_25();
		}

		public void OnReverseMissileTargetReached(Spell missile)
		{
			method_8("OnReverseMissileTargetReached", missile);
		}

		public bool HasImpact()
		{
			return method_11<bool>("HasImpact", Array.Empty<object>());
		}

		public void SpawnAllImpacts()
		{
			method_8("SpawnAllImpacts");
		}

		public void SpawnImpact(int targetIndex)
		{
			method_8("SpawnImpact", targetIndex);
		}

		public Spell DetermineImpactPrefab(GameObject targetObject)
		{
			return method_14<Spell>("DetermineImpactPrefab", new object[1] { targetObject });
		}

		public bool HasChain()
		{
			return method_11<bool>("HasChain", Array.Empty<object>());
		}

		public void SpawnChain()
		{
			method_8("SpawnChain");
		}

		public SpellAreaEffectInfo DetermineAreaEffectInfo()
		{
			return method_14<SpellAreaEffectInfo>("DetermineAreaEffectInfo", Array.Empty<object>());
		}

		public bool HasAreaEffect()
		{
			return method_11<bool>("HasAreaEffect", Array.Empty<object>());
		}

		public bool HasFriendlyAreaEffect()
		{
			return method_11<bool>("HasFriendlyAreaEffect", Array.Empty<object>());
		}

		public bool HasOpponentAreaEffect()
		{
			return method_11<bool>("HasOpponentAreaEffect", Array.Empty<object>());
		}

		public void SpawnAreaEffect(SpellAreaEffectInfo info)
		{
			method_8("SpawnAreaEffect", info);
		}

		public bool AddPrimaryChainTarget()
		{
			return method_11<bool>("AddPrimaryChainTarget", Array.Empty<object>());
		}

		public int GetPrimaryTargetIndex()
		{
			return method_11<int>("GetPrimaryTargetIndex", Array.Empty<object>());
		}

		public GameObject GetPrimaryTarget()
		{
			return method_14<GameObject>("GetPrimaryTarget", Array.Empty<object>());
		}

		public void UpdateTargets()
		{
			method_8("UpdateTargets");
		}

		public int GetVisualTargetCount()
		{
			return method_11<int>("GetVisualTargetCount", Array.Empty<object>());
		}

		public void UpdateVisualTargets()
		{
			method_8("UpdateVisualTargets");
		}

		public void GenerateRandomBoardVisualTargets()
		{
			method_8("GenerateRandomBoardVisualTargets");
		}

		public void GenerateRandomPlayZoneVisualTargets(ZonePlay zonePlay)
		{
			method_8("GenerateRandomPlayZoneVisualTargets", zonePlay);
		}

		public void GenerateRandomVisualTargets(Bounds bounds)
		{
			method_8("GenerateRandomVisualTargets", bounds);
		}

		public void GenerateVisualTarget(Vector3 position, int index, int boxIndex)
		{
			method_8("GenerateVisualTarget", position, index, boxIndex);
		}

		public void GenerateCreatedCardsTargets()
		{
			method_8("GenerateCreatedCardsTargets");
		}

		public void AddChosenTargetAsVisualTarget()
		{
			method_8("AddChosenTargetAsVisualTarget");
		}

		public void AddAllTargetsAsVisualTargets()
		{
			method_8("AddAllTargetsAsVisualTargets");
		}

		public void SuppressPlaySoundsOnVisualTargets()
		{
			method_8("SuppressPlaySoundsOnVisualTargets");
		}

		public void CleanUp()
		{
			method_8("CleanUp");
		}

		public bool HasMetaDataTargets()
		{
			return method_11<bool>("HasMetaDataTargets", Array.Empty<object>());
		}

		public int GetMetaDataIndexForTarget(int visualTargetIndex)
		{
			return method_11<int>("GetMetaDataIndexForTarget", new object[1] { visualTargetIndex });
		}

		public bool ShouldCompleteTasksUntilMetaData(int metaDataIndex)
		{
			return method_11<bool>("ShouldCompleteTasksUntilMetaData", new object[1] { metaDataIndex });
		}

		public void OnMetaDataTasksComplete(PowerTaskList taskList, int startIndex, int count, object userData)
		{
			method_8("OnMetaDataTasksComplete", taskList, startIndex, count, userData);
		}

		public bool IsMakingClones()
		{
			return method_11<bool>("IsMakingClones", Array.Empty<object>());
		}

		public bool AreEffectsActive()
		{
			return method_11<bool>("AreEffectsActive", Array.Empty<object>());
		}

		public Spell CloneSpell(Spell prefab)
		{
			return method_14<Spell>("CloneSpell", new object[1] { prefab });
		}

		public void OnCloneSpellFinished(Spell spell, object userData)
		{
			method_8("OnCloneSpellFinished", spell, userData);
		}

		public void OnCloneSpellStateStarted(Spell spell, SpellStateType prevStateType, object userData)
		{
			method_8("OnCloneSpellStateStarted", spell, prevStateType, userData);
		}

		public void UpdatePendingStateChangeFlags(SpellStateType stateType)
		{
			method_8("UpdatePendingStateChangeFlags", stateType);
		}

		public void FinishIfPossible()
		{
			method_8("FinishIfPossible");
		}
	}
}
